Importing Libraries¶
In [1]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import scipy
%matplotlib inline
plt.style.use('fivethirtyeight')
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
Loading the Dataset :¶
In [2]:
data = pd.read_csv('ml_project1_data_pt.csv',delimiter =',')
data.head(3)
Out[2]:
In [3]:
data.shape
Out[3]:
In [4]:
data.columns
Out[4]:
Data Preprocessing¶
In [4]:
# Checking for null values.
info = pd.DataFrame(data=data.isnull().sum()).T.rename(index={0:'Null values'})
info = info.append(pd.DataFrame(data=data.isnull().sum()/data.shape[0] * 100).T.rename(index={0:'% Null values'}))
info
Out[4]:
In [5]:
# Checking for Duplicates :
data.duplicated().sum()
Out[5]:
In [6]:
data.describe()
Out[6]:
In [7]:
data['dt_primcomp'] = pd.to_datetime(data['dt_primcomp'], errors='coerce')
data['dt_primcomp'] = data['dt_primcomp'].dt.strftime('%m/%Y')
In [8]:
data['age']= 2020 - data['ano_nasc']
In [9]:
data['renda_mes_media']= data['renda_ano']/12
In [10]:
data['campaing_engagement'] =( data['Cmp1']+data['Cmp2']+data['Cmp3']+data['Cmp4']+data['Cmp5']) /5
In [11]:
data['target'] = data['target'].astype(str)
data['Cmp1'] = data['Cmp1'].astype(str)
data['Cmp2'] = data['Cmp2'].astype(str)
data['Cmp3'] = data['Cmp3'].astype(str)
data['Cmp4'] = data['Cmp4'].astype(str)
data['Cmp5'] = data['Cmp5'].astype(str)
data['reclamacoes'] = data['reclamacoes'].astype(str)
In [12]:
data['digital_profile'] = '0'
data['digital_profile'][(data['num_visit_web_ult_mes']< 5) & (data['promocoes_web']<3)]='1'
Exploratory Data Analysis :¶
In [13]:
data.dtypes.groupby(data.dtypes).size()
Out[13]:
In [15]:
dtypes = pd.DataFrame(data.dtypes.rename('type')).reset_index().astype('str')
dtypes = dtypes.query('index != "dt_primcomp"',)
dtypes = dtypes.query('index != "ID"')
dtypes = dtypes.query('index != "target"')
numeric = dtypes[(dtypes.type.isin(['int64', 'float64']))]['index'].values
categorical = dtypes[~(dtypes['index'].isin(numeric)) & (dtypes['index'] != 'target')]['index'].values
print('Numeric:\n', numeric)
print('Categorical:\n', categorical)
Categorical Data Analysis¶
In [830]:
pylab.rcParams['figure.figsize'] = (6.0, 4.0)
In [16]:
for attr in categorical:
figsize=(8,4)
plt.figure()
data[attr].value_counts().plot(kind='bar', color='steelblue');
plt.title(attr);
In [56]:
for attr in categorical:
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,4))
outcome_counts = data.groupby([attr, 'target']).size().rename('count').reset_index()
by_outcome = outcome_counts.pivot(columns='target', values='count', index=attr)
# Plot the proportions
by_outcome.div(by_outcome.sum(1), axis=0).plot.bar(stacked=True, ax=ax1);
# Plot the counts
data[attr].value_counts().plot.bar(ax=ax2, legend=False,color='steelblue');
print('Support (%s)\n' % attr)
print(data[attr].value_counts(), '\n')
plt.title(attr);
Date Analysis¶
In [18]:
data['dt_primcomp'] = pd.to_datetime(data['dt_primcomp'], infer_datetime_format=True)
data.groupby('dt_primcomp')['ID'].nunique().plot(kind='bar')
plt.show()
In [21]:
data['target'] = data['target'].astype(int)
data.groupby('dt_primcomp')['target'].sum().plot(kind='bar')
plt.show()
In [280]:
# campaing
pylab.rcParams['figure.figsize'] = (28, 3)
data.groupby(('dt_primcomp'))['Cmp1','Cmp2','Cmp3','Cmp4','Cmp5'].sum().plot(kind='bar')
plt.title("Campaing Success")
plt.figure( figsize=(20, 18))
plt.show()
Numerical Data Analysis¶
In [22]:
data[numeric].hist(figsize=(18,15));
In [23]:
data[numeric].describe()
Out[23]:
In [24]:
plt.figure(figsize=(16,12));
sns.heatmap(data[numeric].corr('spearman'), annot=True);
Customer Attributes¶
In [37]:
cust_attrs = ['age', 'renda_mes_media', 'num_visit_web_ult_mes','target']
In [38]:
data['target'] = data['target'].astype(str)
numeric_outcome = pd.concat([data[numeric], data['target']], axis=1)
sns.pairplot(numeric_outcome[cust_attrs].sample(n=100), hue='target', aspect=1.2);
Clustering¶
1 . Kmeans
In [14]:
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler
In [16]:
X=data[['renda_ano', 'crianca_casa', 'adoles_casa', 'recencia_dias', 'vinho_montante', 'frutas_montante', 'carne_montante', 'peixe_montante', 'doces_montante', 'ouro_montante', 'promocoes_desconto', 'promocoes_web', 'promocoes_catalogo', 'promocoes_store', 'num_visit_web_ult_mes','age', 'renda_mes_media','campaing_engagement']]
In [17]:
X=X.fillna(0)
In [48]:
# define standard scaler
scaler = StandardScaler()
# transform data
scaled = scaler.fit_transform(X)
print(scaled)
In [49]:
for n_clusters in range(3, 10):
kmeans = KMeans(init='k-means++', n_clusters = n_clusters, n_init = 30)
kmeans.fit(scaled)
clusters = kmeans.predict(scaled)
sil_avg = silhouette_score(scaled, clusters)
print("For n_clusters : ", n_clusters, "The average silhouette_score is : ", sil_avg)
In [54]:
# Choosing number of clusters as 3:
# Trying Improving the silhouette_score :
n_clusters = 3
sil_avg = -1
while sil_avg < 0.145:
kmeans = KMeans(init = 'k-means++', n_clusters = n_clusters, n_init = 30)
kmeans.fit(scaled)
clusters = kmeans.predict(scaled)
sil_avg = silhouette_score(scaled, clusters)
print("For n_clusters : ", n_clusters, "The average silhouette_score is : ", sil_avg)
In [55]:
# Printing number of elements in each cluster :
pd.Series(clusters).value_counts()
Out[55]:
Analysing 4 Cluster¶
In [56]:
def graph_component_silhouette(n_clusters, lim_x, mat_size, sample_silhouette_values, clusters):
import matplotlib as mpl
mpl.rc('patch', edgecolor = 'dimgray', linewidth = 1)
fig, ax1 = plt.subplots(1, 1)
fig.set_size_inches(8, 8)
ax1.set_xlim([lim_x[0], lim_x[1]])
ax1.set_ylim([0, mat_size + (n_clusters + 1) * 10])
y_lower = 10
for i in range(n_clusters):
ith_cluster_silhoutte_values = sample_silhouette_values[clusters == i]
ith_cluster_silhoutte_values.sort()
size_cluster_i = ith_cluster_silhoutte_values.shape[0]
y_upper = y_lower + size_cluster_i
ax1.fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_silhoutte_values, alpha = 0.8)
ax1.text(-0.03, y_lower + 0.5 * size_cluster_i, str(i), color = 'red', fontweight = 'bold',
bbox = dict(facecolor = 'white', edgecolor = 'black', boxstyle = 'round, pad = 0.3'))
y_lower = y_upper + 10
In [57]:
# Plotting the intra cluster silhouette distances.
from sklearn.metrics import silhouette_samples
sample_silhouette_values = silhouette_samples(scaled, clusters)
graph_component_silhouette(n_clusters, [-0.07, 0.33], len(X), sample_silhouette_values, clusters)
Dimensionality Reduction¶
PCA
In [58]:
from sklearn.decomposition import PCA
In [59]:
pca = PCA()
pca.fit(scaled)
pca_samples = pca.transform(scaled)
In [60]:
# Checking the amount of variance explained :
fig, ax = plt.subplots(figsize=(14, 5))
sns.set(font_scale=1)
plt.step(range(scaled.shape[1]), pca.explained_variance_ratio_.cumsum(), where = 'mid', label = 'Cummulative Variance Explained')
sns.barplot(np.arange(1, scaled.shape[1] + 1), pca.explained_variance_ratio_, alpha = 0.5, color = 'g',
label = 'Individual Variance Explained')
plt.xlim(0, 20)
plt.xticks(rotation = 45, fontsize = 16)
ax.set_xticklabels([s for s in ax.get_xticklabels()])
plt.ylabel("Explained Variance", fontsize = 18)
plt.xlabel("Principal Components", fontsize = 18)
plt.legend(loc = 'upper right', fontsize = 12)
plt.show()
In [61]:
data['fit_segmentacao']= kmeans.labels_
In [62]:
data
Out[62]:
In [63]:
data['fit_segmentacao'] = data['fit_segmentacao'].astype(str)
Fit Segmentação Analysis¶
In [64]:
from pandas_profiling import ProfileReport
profile = ProfileReport(data, title="Data Profile Report")
In [65]:
profile
Out[65]:
In [188]:
# Customer
data.groupby(['fit_segmentacao']).fit_segmentacao.count().sort_values().plot(kind='bar')
data.groupby(['fit_segmentacao']).fit_segmentacao.count().sort_values()
Out[188]:
In [176]:
num_cluster = data[['renda_mes_media','age','crianca_casa','adoles_casa','recencia_dias','num_visit_web_ult_mes','campaing_engagement']]
In [177]:
for att in num_cluster:
figsize=(8,4)
plt.figure()
data[att].hist(by=data['fit_segmentacao'],figsize=(12,9))
plt.title(att);
In [178]:
for att in num_cluster:
print (att)
print( data.groupby('fit_segmentacao', as_index=True)[att].describe())
In [187]:
data['digital_profile'] = data['digital_profile'].astype(int)
data.groupby(['fit_segmentacao'])['digital_profile'].sum().plot.bar()
data.groupby(['fit_segmentacao'])['digital_profile'].sum()
Out[187]:
Classifying the Customers :¶
In [198]:
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
class Class_Fit(object):
def __init__(self, clf, params = None):
if params:
self.clf = clf(**params)
else:
self.clf = clf()
def train(self, x_train, y_train):
self.clf.fit(x_train, y_train)
def predict(self, x):
return self.clf.predict(x)
def grid_search(self, parameters, Kfold):
self.grid = GridSearchCV(estimator = self.clf, param_grid = parameters, cv = Kfold)
def grid_fit(self, X, Y):
self.grid.fit(X, Y)
def grid_predict(self, X, Y):
self.predictions = self.grid.predict(X)
print("Precision: {:.2f} %".format(100 * accuracy_score(Y, self.predictions)))
In [197]:
data['target'].dtypes
Out[197]:
In [206]:
data['target'] = data['target'].astype(str)
In [210]:
columns = ['renda_mes_media', 'age','recencia_dias','vinho_montante','frutas_montante','carne_montante','peixe_montante','doces_montante','ouro_montante','promocoes_desconto','promocoes_web','promocoes_catalogo','promocoes_store','num_visit_web_ult_mes','Cmp3','Cmp4','Cmp5','Cmp1','Cmp2','reclamacoes','fit_segmentacao','campaing_engagement']
X = data[columns]
Y = data['target']
In [72]:
Y=Y.astype(int)
n_instances = len(X)
p_instances = Y.sum() / len(Y)
p_targeted = 0.15
n_targeted = int(n_instances*p_targeted)
print('Number of instances: {:,}'.format(n_instances))
print('Number of conversions {:,}'.format(Y.sum()))
print('Conversion rate: {:.2f}%'.format(p_instances*100.))
print('15% of the population {:,}'.format(n_targeted))
print('Expected number of conversions targetting {:,} @ {:.2f}%: {:,}'.format(n_targeted, p_instances*100., int(p_instances * n_targeted)))
Train, Test Splitting¶
In [208]:
from sklearn.model_selection import train_test_split
In [213]:
X=X.fillna(0)
X=X.astype(int)
Y=Y.astype(str)
In [214]:
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size = 0.8)
Training Models :¶
In [215]:
from sklearn.svm import LinearSVC
from warnings import simplefilter
from sklearn.exceptions import ConvergenceWarning
simplefilter("ignore", category=ConvergenceWarning)
In [216]:
svc = Class_Fit(clf=LinearSVC)
svc.grid_search(parameters = [{'C':np.logspace(-2,2,10)}], Kfold = 5)
In [217]:
svc.grid_fit(X=X_train, Y=Y_train)
In [218]:
svc.grid_predict(X_test, Y_test)
In [219]:
from sklearn.metrics import confusion_matrix
In [220]:
class_names = [i for i in range(1,11)]
cnf = confusion_matrix(Y_test, svc.predictions)
cnf
Out[220]:
In [221]:
# Code from sklearn documentation.
from sklearn.model_selection import learning_curve
from sklearn.model_selection import ShuffleSplit
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)):
"""
Generate a simple plot of the test and training learning curve.
"""
plt.figure()
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel("Training examples")
plt.ylabel("Score")
train_sizes, train_scores, test_scores = learning_curve(
estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.grid()
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1, color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
label="Cross-validation score")
plt.legend(loc="best")
return plt
In [226]:
g = plot_learning_curve(svc.grid.best_estimator_, "SVC Learning Curve", X_train, Y_train, ylim=[0.95, 0.55], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
Logistic Regression¶
In [227]:
from sklearn.linear_model import LogisticRegression
In [228]:
lr = Class_Fit(clf = LogisticRegression)
lr.grid_search(parameters = [{'C':np.logspace(-4,6,16)}], Kfold = 17)
lr.grid_fit(X_train, Y_train)
lr.grid_predict(X_test, Y_test)
In [229]:
cnf = confusion_matrix(Y_test, lr.predictions)
cnf
Out[229]:
In [230]:
g = plot_learning_curve(lr.grid.best_estimator_, "LogisticRegression Learning Curve", X_train, Y_train, ylim=[.95, 0.75], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
K-Nearest Neighbours :¶
In [231]:
from sklearn.neighbors import KNeighborsClassifier
In [232]:
knn = Class_Fit(clf = KNeighborsClassifier)
knn.grid_search(parameters = [{'n_neighbors':np.arange(1,50,1)}], Kfold = 10)
knn.grid_fit(X_train, Y_train)
knn.grid_predict(X_test, Y_test)
In [233]:
cnf = confusion_matrix(Y_test, knn.predictions)
cnf
Out[233]:
In [234]:
g = plot_learning_curve(knn.grid.best_estimator_, "KNearestNEighbors Learning Curve", X_train, Y_train, ylim=[.9, 0.8], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
Decision Trees :¶
In [235]:
from sklearn.tree import DecisionTreeClassifier
In [236]:
tr = Class_Fit(clf = DecisionTreeClassifier)
tr.grid_search(parameters = [{'criterion':['entropy', 'gini'], 'max_features':['sqrt', 'log2']}], Kfold = 3)
tr.grid_fit(X_train, Y_train)
tr.grid_predict(X_test, Y_test)
In [237]:
cnf = confusion_matrix(Y_test, tr.predictions)
cnf
Out[237]:
In [238]:
g = plot_learning_curve(tr.grid.best_estimator_, "DecisionTree Learning Curve", X_train, Y_train, ylim=[1.01, 0.75], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
Random Forests:¶
In [239]:
from sklearn.ensemble import RandomForestClassifier
In [240]:
rf = Class_Fit(clf = RandomForestClassifier)
rf.grid_search(parameters = [{'criterion':['entropy', 'gini'],
'max_features':['sqrt', 'log2'], 'n_estimators':[40, 60, 80, 100, 140]}], Kfold = 5)
rf.grid_fit(X_train, Y_train)
rf.grid_predict(X_test, Y_test)
In [258]:
cnf = confusion_matrix(Y_test, rf.predictions)
cnf
Out[258]:
In [241]:
g = plot_learning_curve(rf.grid.best_estimator_, "Random Forest Learning Curve", X_train, Y_train, ylim=[1.01, 0.8], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
In [242]:
from sklearn.ensemble import AdaBoostClassifier
In [244]:
ada = Class_Fit(clf = AdaBoostClassifier)
ada.grid_search(parameters = [{'n_estimators':[20, 30, 40, 50, 60, 70, 80, 90, 100, 120, 130]}], Kfold = 8)
ada.grid_fit(X_train, Y_train)
ada.grid_predict(X_test, Y_test)
In [245]:
cnf = confusion_matrix(Y_test, ada.predictions)
cnf
Out[245]:
In [246]:
g = plot_learning_curve(ada.grid.best_estimator_, "AdaBoost Learning Curve", X_train, Y_train, ylim=[1.01, 0.8], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
Gradient Boosted Decision Trees :¶
In [248]:
import xgboost
In [249]:
gbdt = Class_Fit(clf = xgboost.XGBClassifier)
gbdt.grid_search(parameters = [{'n_estimators':[20, 30, 40, 50, 60, 70, 80, 90, 100, 120]}], Kfold = 5)
gbdt.grid_fit(X_train, Y_train)
gbdt.grid_predict(X_test, Y_test)
In [250]:
cnf = confusion_matrix(Y_test, gbdt.predictions)
cnf
Out[250]:
In [251]:
g = plot_learning_curve(gbdt.grid.best_estimator_, "GBDT Learning Curve", X_train, Y_train, ylim=[1.01, 0.8], cv = 5,
train_sizes = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
Voting Classifier :¶
In [252]:
rf_best = RandomForestClassifier(**rf.grid.best_params_)
gbdt_best = xgboost.XGBClassifier(**gbdt.grid.best_params_)
svc_best = LinearSVC(**svc.grid.best_params_)
tr_best = DecisionTreeClassifier(**tr.grid.best_params_)
knn_best = KNeighborsClassifier(**knn.grid.best_params_)
lr_best = LogisticRegression(**lr.grid.best_params_)
In [253]:
from sklearn.ensemble import VotingClassifier
In [263]:
votingC = VotingClassifier(estimators=[('rf', rf_best), ('gb', gbdt_best), ('knn', knn_best), ('lr', lr_best),('svc', svc_best),('tr', tr_best)])
In [264]:
votingC = votingC.fit(X_train, Y_train)
In [265]:
predictions = votingC.predict(X_test)
In [266]:
print("Precision : {:.2f}%".format(100 * accuracy_score(Y_test, predictions)))
In [267]:
from sklearn.metrics import classification_report
print(classification_report(Y_test, predictions))
Testing Model¶
In [268]:
X
Out[268]:
In [269]:
# define standard scaler
scaler = StandardScaler()
# transform data
scaled = scaler.fit_transform(X)
In [270]:
predictions = votingC.predict(X)
In [271]:
print("Precision : {:.2f}%".format(100 * accuracy_score(Y, predictions)))